import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
from statsmodels.tsa.seasonal import seasonal_decompose
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.tsa.holtwinters import ExponentialSmoothing
import wordcloud
from wordcloud import WordCloud
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error
from pmdarima import auto_arima
from datetime import datetime
from lifelines import KaplanMeierFitter
from lifelines import CoxPHFitter

warnings.filterwarnings("ignore")

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[1], line 18
     16 from sklearn.metrics import mean_squared_error, r2_score
     17 from statsmodels.tsa.holtwinters import ExponentialSmoothing
---> 18 import wordcloud
     19 from wordcloud import WordCloud
     20 from statsmodels.tsa.arima.model import ARIMA

ModuleNotFoundError: No module named 'wordcloud'

data_swire = pd.read_csv('IWC_Work_Orders_Extract.csv', low_memory=False)

data_swire_copy = data_swire.copy()

data_swire_copy.head(n=10)

# Check column names and data types
data_swire_copy.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1427264 entries, 0 to 1427263
Data columns (total 25 columns):
 #   Column                           Non-Null Count    Dtype  
---  ------                           --------------    -----  
 0   ORDER_ID                         1427264 non-null  int64  
 1   PLANT_ID                         1427264 non-null  object 
 2   PRODUCTION_LOCATION              1427264 non-null  object 
 3   EXECUTION_START_DATE             1427264 non-null  object 
 4   EXECUTION_FINISH_DATE            1427264 non-null  object 
 5   ACTUAL_START_TIME                1427264 non-null  object 
 6   ACTUAL_FINISH_TIME               1427264 non-null  object 
 7   ACTUAL_WORK_IN_MINUTES           1427264 non-null  float64
 8   MAINTENANCE_PLAN                 152594 non-null   object 
 9   MAINTENANCE_ITEM                 152594 non-null   float64
 10  MAINTENANCE_ACTIVITY_TYPE        1427264 non-null  object 
 11  ORDER_DESCRIPTION                291767 non-null   object 
 12  MAINTENANCE_TYPE_DESCRIPTION     291795 non-null   object 
 13  FUNCTIONAL_LOC                   291782 non-null   object 
 14  FUNCTIONAL_AREA_NODE_1_MODIFIED  290117 non-null   object 
 15  FUNCTIONAL_AREA_NODE_2_MODIFIED  282407 non-null   object 
 16  FUNCTIONAL_AREA_NODE_3_MODIFIED  258691 non-null   object 
 17  FUNCTIONAL_AREA_NODE_4_MODIFIED  237573 non-null   object 
 18  FUNCTIONAL_AREA_NODE_5_MODIFIED  2180 non-null     object 
 19  EQUIPMENT_ID                     291795 non-null   float64
 20  EQUIPMENT_DESC                   79447 non-null    object 
 21  EQUIP_CAT_DESC                   79447 non-null    object 
 22  EQUIP_START_UP_DATE              79447 non-null    object 
 23  EQUIP_VALID_FROM                 79447 non-null    object 
 24  EQUIP_VALID_TO                   79447 non-null    object 
dtypes: float64(3), int64(1), object(21)
memory usage: 272.2+ MB

data_swire_copy.shape

(1427264, 25)

median_survival_times_dict = {}
for equipment_type in equipment_types:
    type_data = data_swire_copy[data_swire_copy['Equipment_Type'] == equipment_type.capitalize()]
    if not type_data.empty:
        kmf.fit(type_data['machine_age'], event_observed=type_data['failure_event'])
        median_survival = median_survival_times(kmf.survival_function_)
        median_survival_times_dict[equipment_type] = median_survival.values[0][0]

# Simulate the impact of planned maintenance
data_swire_copy['preventive_maintenance'] = data_swire_copy['machine_age'].apply(
    lambda x: 1 if any(x < median_survival_times_dict[etype] for etype in equipment_types if etype in str(data_swire_copy['EQUIPMENT_DESC'].iloc[0]).lower()) else 0
)

# Compare unplanned maintenance with and without the intervention
before_intervention = data_swire_copy['failure_event'].sum()
after_intervention = data_swire_copy.loc[data_swire_copy['preventive_maintenance'] == 0, 'failure_event'].sum()

print(f"Unplanned maintenance events before intervention: {before_intervention}")
print(f"Unplanned maintenance events after intervention: {after_intervention}")

# Calculate downtime reduction
downtime_reduction = (before_intervention - after_intervention) / before_intervention * 100
print(f"Estimated reduction in unplanned maintenance events: {downtime_reduction:.2f}%")

Unplanned maintenance events before intervention: 79447
Unplanned maintenance events after intervention: 79447
Estimated reduction in unplanned maintenance events: 0.00%

data_swire_copy.dtypes

data_swire_copy.columns

Index(['ORDER_ID', 'PLANT_ID', 'PRODUCTION_LOCATION', 'EXECUTION_START_DATE',
       'EXECUTION_FINISH_DATE', 'ACTUAL_START_TIME', 'ACTUAL_FINISH_TIME',
       'ACTUAL_WORK_IN_MINUTES', 'MAINTENANCE_PLAN', 'MAINTENANCE_ITEM',
       'MAINTENANCE_ACTIVITY_TYPE', 'ORDER_DESCRIPTION',
       'MAINTENANCE_TYPE_DESCRIPTION', 'FUNCTIONAL_LOC',
       'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
       'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
       'FUNCTIONAL_AREA_NODE_5_MODIFIED', 'EQUIPMENT_ID', 'EQUIPMENT_DESC',
       'EQUIP_CAT_DESC', 'EQUIP_START_UP_DATE', 'EQUIP_VALID_FROM',
       'EQUIP_VALID_TO'],
      dtype='object')

data_swire_copy.isnull().sum()

# Calculate the percentage of missing values for each column
missing_values_percentage = data_swire_copy.isnull().mean() * 100

# Filter out columns that have no missing values
missing_values_percentage = missing_values_percentage[missing_values_percentage > 0]

print(missing_values_percentage)

MAINTENANCE_PLAN                   89.308635
MAINTENANCE_ITEM                   89.308635
ORDER_DESCRIPTION                  79.557601
MAINTENANCE_TYPE_DESCRIPTION       79.555639
FUNCTIONAL_LOC                     79.556550
FUNCTIONAL_AREA_NODE_1_MODIFIED    79.673207
FUNCTIONAL_AREA_NODE_2_MODIFIED    80.213401
FUNCTIONAL_AREA_NODE_3_MODIFIED    81.875042
FUNCTIONAL_AREA_NODE_4_MODIFIED    83.354656
FUNCTIONAL_AREA_NODE_5_MODIFIED    99.847260
EQUIPMENT_ID                       79.555639
EQUIPMENT_DESC                     94.433616
EQUIP_CAT_DESC                     94.433616
EQUIP_START_UP_DATE                94.433616
EQUIP_VALID_FROM                   94.433616
EQUIP_VALID_TO                     94.433616
dtype: float64

# Plotting the bar plot
plt.figure(figsize=(13, 8))
missing_values_percentage.sort_values().plot(kind='barh', color='skyblue')
plt.xlabel('Percentage of Missing Values')
plt.ylabel('Columns')
plt.title('Percentage of Missing Values by Column')

# Add numerical values on the bars
for index, value in enumerate(missing_values_percentage.sort_values()):
    plt.text(value + 0.5, index, f'{value:.2f}%', va='center')

plt.show()

categorical_columns = ['MAINTENANCE_PLAN', 'MAINTENANCE_ITEM', 'ORDER_DESCRIPTION', 'MAINTENANCE_TYPE_DESCRIPTION',
                       'FUNCTIONAL_LOC', 'FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
                       'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED', 'FUNCTIONAL_AREA_NODE_5_MODIFIED',
                       'EQUIPMENT_ID', 'EQUIPMENT_DESC', 'EQUIP_CAT_DESC']

for col in categorical_columns:
    data_swire_copy[col] = data_swire_copy[col].fillna('Unknown')

data_swire_copy['EQUIP_START_UP_DATE'] = pd.to_datetime(data_swire_copy['EQUIP_START_UP_DATE'], errors='coerce')
data_swire_copy['EQUIP_START_UP_DATE'] = data_swire_copy['EQUIP_START_UP_DATE'].fillna(pd.to_datetime('1960-01-01'))

data_swire_copy['EQUIP_VALID_FROM'] = np.where(
    data_swire_copy['EQUIP_VALID_FROM'].isna(),
    data_swire_copy['EQUIP_START_UP_DATE'] + pd.Timedelta(days=0),
    data_swire_copy['EQUIP_VALID_FROM']
)

data_swire_copy.fillna({'EQUIP_VALID_TO': pd.to_datetime('2200-01-01')}, inplace=True)


data_swire_copy['EQUIPMENT_DESC'] = data_swire_copy['EQUIPMENT_DESC'].fillna(data_swire_copy['EQUIPMENT_DESC'].mode()[0])
data_swire_copy['EQUIP_CAT_DESC'] = data_swire_copy['EQUIP_CAT_DESC'].fillna(data_swire_copy['EQUIP_CAT_DESC'].mode()[0])

data_swire_copy.isnull().sum()

data_swire_copy.head(n=10)

data_swire_copy['ACTUAL_WORK_IN_MINUTES'].describe().round(2)

warnings.filterwarnings("ignore", category=FutureWarning, module="pandas")

sns.histplot(data_swire_copy['ACTUAL_WORK_IN_MINUTES'], bins=30, kde=True)
plt.title('Distribution of Actual Work in Minutes')
plt.xlabel('Actual Work in Minutes')
plt.ylabel('Frequency')
plt.show()

plt.figure(figsize=(12, 6))
location_counts = data_swire_copy['PRODUCTION_LOCATION'].value_counts()
sns.barplot(x=location_counts.values, y=location_counts.index, palette='viridis')
plt.title('Breakdown Counts by Production Location')
plt.xlabel('Number of Breakdowns')
plt.ylabel('Production Location')
plt.tight_layout()
plt.show()

# Convert 'EXECUTION_START_DATE' to datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')

# Grouping breakdowns by year
breakdown_trends_yearly = data_swire_copy['EXECUTION_START_DATE'].groupby(data_swire_copy['EXECUTION_START_DATE'].dt.year).count()

# Plotting breakdown trends over time by year
plt.figure(figsize=(12, 6))
breakdown_trends_yearly.plot(kind='line', marker='o', color='b')
plt.title('Breakdown Trends Over Years')
plt.xlabel('Year')
plt.ylabel('Number of Breakdowns')
plt.xticks(breakdown_trends_yearly.index, rotation=45)

plt.tight_layout()
plt.show()

# Assuming 'EXECUTION_START_DATE' is already converted to datetime
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Filter data for a specific year
specific_year = 2023
data_specific_year = data_swire_copy[data_swire_copy['EXECUTION_START_DATE'].dt.year == specific_year]

# Grouping by month within the specific year
monthly_counts = data_specific_year['EXECUTION_START_DATE'].groupby(data_specific_year['EXECUTION_START_DATE'].dt.month).count()

# Plotting the number of maintenance activities per month in the specific year
monthly_counts.plot(kind='line', marker='o', figsize=(10, 6))
plt.title(f'Number of Maintenance Activities per Month in {specific_year}')
plt.xlabel('Month')
plt.ylabel('Number of Maintenance Activities')
plt.xticks(ticks=range(1, 13), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
plt.tight_layout()
plt.show()

# Bar chart for MAINTENANCE_ACTIVITY_TYPE
plt.figure(figsize=(10, 6))
sns.countplot(x='MAINTENANCE_ACTIVITY_TYPE', data=data_swire_copy)
plt.title('Frequency of Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.ticklabel_format(style='plain', axis='y')
plt.show()

data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].value_counts()

# Grouping the data by MAINTENANCE_ACTIVITY_TYPE and calculating the mean of ACTUAL_WORK_IN_MINUTES
grouped_data = data_swire_copy.groupby('MAINTENANCE_ACTIVITY_TYPE')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Plotting the average downtime (ACTUAL_WORK_IN_MINUTES) for each Maintenance Activity Type
plt.figure(figsize=(12, 8))
bar_plot = sns.barplot(x='MAINTENANCE_ACTIVITY_TYPE', y='ACTUAL_WORK_IN_MINUTES', data=grouped_data, palette='viridis')

# Customizing the plot
plt.title('Average Downtime (Actual Work in Minutes) by Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=45)

# Adding values to each bar in the plot
for index, row in grouped_data.iterrows():
    bar_plot.text(index, row['ACTUAL_WORK_IN_MINUTES'], f'{row["ACTUAL_WORK_IN_MINUTES"]:.2f}',
                  ha='center', va='bottom', fontsize=10, color='black')

plt.tight_layout()
plt.show()

grouped_data = data_swire_copy.groupby('PLANT_ID')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Re-plotting as requested without numerical values and with red color bars
plt.figure(figsize=(12, 6))
bar_plot = sns.barplot(
    x='PLANT_ID',
    y='ACTUAL_WORK_IN_MINUTES',
    data=grouped_data,
    color='red',  # Use solid red color
    errorbar=None
)

# Customizing the plot
plt.title('Average Downtime by Plant', fontsize=14)
plt.xlabel('Plant ID', fontsize=12)
plt.ylabel('Average Actual Work in Minutes', fontsize=12)
plt.xticks(rotation=45, fontsize=10)
plt.yticks(fontsize=10)

# Adjust layout and show the plot
plt.tight_layout()
plt.show()

plt.figure(figsize=(12, 6))
count_plot = sns.countplot(x='MAINTENANCE_ACTIVITY_TYPE', hue='MAINTENANCE_TYPE_DESCRIPTION', data=data_swire_copy, palette='viridis')
plt.title('Count of Maintenance Type by Maintenance Activity Type')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
for p in count_plot.patches:
    count_plot.annotate(format(p.get_height(), '.0f'),
                        (p.get_x() + p.get_width() / 2., p.get_height()),
                        ha='center', va='center', xytext=(0, 6), textcoords='offset points', fontsize=9, color='black')
plt.tight_layout()
plt.show()

print(data_swire_copy['FUNCTIONAL_AREA_NODE_4_MODIFIED'].value_counts())

FUNCTIONAL_AREA_NODE_4_MODIFIED
FILLER                      46322
PACKER                      35230
CONVEYOR                    34765
LABELER                     18945
PALLETIZER                  16239
                            ...  
MIXERS                          1
BATCH STATION METER SKID        1
G811 CONDENSATE RETURN          1
CIP TANK SKID                   1
CIP VALVE MATRIX SKID           1
Name: count, Length: 86, dtype: int64

print(data_swire_copy['FUNCTIONAL_AREA_NODE_5_MODIFIED'].value_counts())

FUNCTIONAL_AREA_NODE_5_MODIFIED
FULL CAN TO ACCUMULATION TABLE              251
PACKER 1, MODEL DUODOZEN 1250SX             210
FULL CASE CONVEYORS                         158
EMPTY CASE CONVEYORS                        136
FULL CASE SPIRAL TO PALLETIZER              125
FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT       114
EMPTY CAN                                   110
COMPRESSOR                                  110
PACKER 2, MODEL FENIX 185V                  108
FULL CASE CONVEYOR                          101
EAST SYRUP TANKS                             98
FULL BOTTLE CONVEYORS                        97
EMPTY CAN CONVEYOR                           90
*OLD SYSTEM MT CASE CONVEYORS*               56
LOOSE FB TO PACKER CONVEYORS                 52
FULL CAN CONVEYOR                            50
EVANS COOLING TUNNEL L3, INSIDE BUILDING     48
HARTNESS TO PAI FULL CASE CONVEYORS          47
PARTIAL CASES GPI (RIVERWOOD) TO DOUGLAS     43
INFEED TO HICONE TO PACKER                   33
EMPTY CAN VACUUM BLOWERS                     26
FULL CAN INFEED GPI                          24
DEPAL TO FILLER MT BOTTLE CONVEYORS          17
ACCUMULATION TABLES                          16
FULL CAN INFEED DOUGLAS/GPI (RIVERWOOD)      12
FULL CASE GPI (RIVERWOOD)                    10
FULL CASE FROM DOUGLAS TO PAI                 9
FULL CASE DOUGLAS                             7
PACK CONVEYOR                                 6
EVANS COOLING TUNNEL L3, OUTSIDE BUILDIN      5
CONVEYORS FOR PALLETIZER                      4
BLOWER SECTION #12 ACE-3-M112                 3
FB INFEED TO DOUGLAS CONVEYORS                1
BLOWER SECTION #1 ACE-3-M101                  1
BLOWER SECTION #11 ACE-3-M111                 1
PALLET CONVEYOR                               1
Name: count, dtype: int64

avg_downtime = data_swire_copy.groupby('FUNCTIONAL_AREA_NODE_4_MODIFIED')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

plt.figure(figsize=(12, 6))
sns.barplot(x='FUNCTIONAL_AREA_NODE_4_MODIFIED', y='ACTUAL_WORK_IN_MINUTES', data=avg_downtime, palette='viridis')
plt.title('Average Downtime by Functional Area Node 4')
plt.xlabel('Functional Area Node 4')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=90)
plt.show()

# Grouping the data by FUNCTIONAL_AREA_NODE_5_MODIFIED and calculating the average downtime (ACTUAL_WORK_IN_MINUTES)
average_downtime_node5 = data_swire_copy.groupby('FUNCTIONAL_AREA_NODE_5_MODIFIED')['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Sorting the values for better visualization
average_downtime_node5 = average_downtime_node5.sort_values(by='ACTUAL_WORK_IN_MINUTES', ascending=False)

# Plotting the average downtime by Functional Area Node 5
plt.figure(figsize=(12, 8))
sns.barplot(x='ACTUAL_WORK_IN_MINUTES', y='FUNCTIONAL_AREA_NODE_5_MODIFIED', data=average_downtime_node5, palette='viridis')
plt.title('Average Downtime by Functional Area Node 5')
plt.xlabel('Average Actual Work in Minutes')
plt.ylabel('Functional Area Node 5')

for index, value in enumerate(average_downtime_node5['ACTUAL_WORK_IN_MINUTES']):
    plt.text(value, index, f'{value:.2f}', va='center', ha='left')

plt.tight_layout()
plt.show()

plt.figure(figsize=(12, 6))
count_plot = sns.countplot(x='EQUIP_CAT_DESC', hue='MAINTENANCE_TYPE_DESCRIPTION', data=data_swire_copy, palette='viridis')
plt.title('Frequency of Maintenance Type Across Equipment Categories')
plt.xlabel('Equipment Category')
plt.ylabel('Count')
plt.xticks(rotation=45)

# Adding values on top of each bar
for p in count_plot.patches:
    count_plot.annotate(format(p.get_height(), '.0f'),
                        (p.get_x() + p.get_width() / 2., p.get_height()),
                        ha='center', va='center', xytext=(0, 5), textcoords='offset points')

plt.tight_layout()
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy['EQUIP_VALID_FROM'] = pd.to_datetime(data_swire_copy['EQUIP_VALID_FROM'], errors='coerce')

# Calculate equipment age in years
data_swire_copy['EQUIP_AGE'] = (data_swire_copy['EXECUTION_START_DATE'] - data_swire_copy['EQUIP_VALID_FROM']).dt.days / 365

# Filter for records where equipment age is greater than 0
filtered_data = data_swire_copy[data_swire_copy['EQUIP_AGE'] > 0]

# Scatter plot of equipment age vs actual work in minutes
plt.figure(figsize=(10, 6))
sns.scatterplot(x='EQUIP_AGE', y='ACTUAL_WORK_IN_MINUTES', data=filtered_data, alpha=0.6)
plt.title("Scatter Plot of Equipment Age vs Actual Work in Minutes")
plt.xlabel("Equipment Age (years)")
plt.ylabel("Actual Work in Minutes")
plt.show()

# Grouping data by MAINTENANCE_ACTIVITY_TYPE and PLANT_ID and calculating the mean of ACTUAL_WORK_IN_MINUTES
grouped_data = data_swire_copy.groupby(['MAINTENANCE_ACTIVITY_TYPE', 'PLANT_ID'])['ACTUAL_WORK_IN_MINUTES'].mean().reset_index()

# Plotting a bar plot with hue to differentiate plants
plt.figure(figsize=(12, 6))
sns.barplot(x='MAINTENANCE_ACTIVITY_TYPE', y='ACTUAL_WORK_IN_MINUTES', hue='PLANT_ID', data=grouped_data, palette='viridis')

# Customizing the plot
plt.title('Average Downtime by Maintenance Activity Type for Different Plants')
plt.xlabel('Maintenance Activity Type')
plt.ylabel('Average Actual Work in Minutes')
plt.xticks(rotation=45)
plt.legend(title='Plant ID')
plt.tight_layout()
plt.show()

# Filter for records where equipment age is greater than 0
filtered_data = data_swire_copy[data_swire_copy['EQUIP_AGE'] > 0]

# Scatter plot to visualize the relationship between equipment age and maintenance type
plt.figure(figsize=(10, 6))
sns.scatterplot(x='EQUIP_AGE', y='ACTUAL_WORK_IN_MINUTES', hue='MAINTENANCE_TYPE_DESCRIPTION', data=filtered_data, alpha=0.6, palette='viridis')
plt.title('Maintenance Type by Equipment Age and Downtime (Age > 0)')
plt.xlabel('Equipment Age (Years)')
plt.ylabel('Actual Work in Minutes')
plt.tight_layout()
plt.show()

# Calculate Q1  and Q3
Q1 = data_swire_copy['ACTUAL_WORK_IN_MINUTES'].quantile(0.25)
Q3 = data_swire_copy['ACTUAL_WORK_IN_MINUTES'].quantile(0.75)
IQR = Q3 - Q1

# Define lower and upper bounds for outliers
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Identify outliers
outliers = data_swire_copy[(data_swire_copy['ACTUAL_WORK_IN_MINUTES'] < lower_bound) |
                           (data_swire_copy['ACTUAL_WORK_IN_MINUTES'] > upper_bound)]
print(f"Number of outliers: {len(outliers)}")

Number of outliers: 101066

# Remove outliers from the dataset
data_swire_copy_no_outliers = data_swire_copy[(data_swire_copy['ACTUAL_WORK_IN_MINUTES'] >= lower_bound) &
                                              (data_swire_copy['ACTUAL_WORK_IN_MINUTES'] <= upper_bound)]
print(f"Number of rows after removing outliers: {len(data_swire_copy_no_outliers)}")

Number of rows after removing outliers: 1326198

# Boxplot after handling outliers
plt.figure(figsize=(12, 6))
sns.boxplot(x=data_swire_copy['ACTUAL_WORK_IN_MINUTES'], palette='viridis')
plt.title('Boxplot of Actual Work in Minutes After Handling Outliers')
plt.xlabel('Actual Work in Minutes')
plt.show()

data_swire_copy.shape

(1427264, 26)

# Ensure the 'EXECUTION_START_DATE' column is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')

# Extract the year from the 'EXECUTION_START_DATE' column
data_swire_copy['Year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year

# Group by year and count the work orders for each year
yearly_work_orders = data_swire_copy.groupby('Year').size().reset_index(name='Work_Order_Count')

# Display the year-wise work order count
print(yearly_work_orders)

   Year  Work_Order_Count
0  2013                 1
1  2016             15508
2  2017             86733
3  2018            142990
4  2019            149477
5  2020            136490
6  2021            134068
7  2022            129582
8  2023            147483
9  2024            106243

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Extract year, month, week, and day of the week
data_swire_copy['year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year
data_swire_copy['month'] = data_swire_copy['EXECUTION_START_DATE'].dt.month
data_swire_copy['week'] = data_swire_copy['EXECUTION_START_DATE'].dt.isocalendar().week
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()

# Count downtime instances per day of the week for each week, month, and year
weekly_downtime = data_swire_copy.groupby(['year', 'month', 'week', 'day_of_week']).size().reset_index(name='downtime_count')

# Reorder day_of_week for proper plotting order
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
weekly_downtime['day_of_week'] = pd.Categorical(weekly_downtime['day_of_week'], categories=day_order, ordered=True)

# Summarize downtime counts across all weeks, months, and years for each day of the week
downtime_summary = weekly_downtime.groupby('day_of_week')['downtime_count'].sum()

# Plot weekly downtime pattern, aggregated across all weeks, months, and years
plt.figure(figsize=(10, 6))
downtime_summary.plot(kind='bar', color='lightcoral')
plt.title("Weekly Downtime Pattern (Aggregated by All Weeks, Months, and Years)")
plt.xlabel("Day of the Week")
plt.ylabel("Total Downtime Count")
plt.xticks(rotation=45)
plt.show()

C:\Users\u1478229\AppData\Local\Temp\ipykernel_7708\4009809684.py:18: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.
  downtime_summary = weekly_downtime.groupby('day_of_week')['downtime_count'].sum()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Extract year and day of the week
data_swire_copy['year'] = data_swire_copy['EXECUTION_START_DATE'].dt.year
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()

# Count downtime instances per day of the week for each year
yearly_downtime = data_swire_copy.groupby(['year', 'day_of_week']).size().reset_index(name='downtime_count')

# Reorder day_of_week for consistent plotting order
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
yearly_downtime['day_of_week'] = pd.Categorical(yearly_downtime['day_of_week'], categories=day_order, ordered=True)

# Loop through each year and plot downtime pattern for that year
for year in yearly_downtime['year'].unique():
    # Filter data for the specific year
    data_for_year = yearly_downtime[yearly_downtime['year'] == year].set_index('day_of_week').reindex(day_order).fillna(0)

    # Plot for the specific year
    plt.figure(figsize=(8, 5))
    data_for_year['downtime_count'].plot(kind='bar', color='skyblue')
    plt.title(f"Downtime Pattern by Day of the Week for {year}")
    plt.xlabel("Day of the Week")
    plt.ylabel("Downtime Count")
    plt.xticks(rotation=45)
    plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date to calculate intervals
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference (in days) between consecutive failures for each machine
data_swire_copy['time_since_last_failure'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Drop any NaN values that result from the first failure in each machine's series
data_swire_copy = data_swire_copy.dropna(subset=['time_since_last_failure'])

# Calculate average MTBF over time by month or year (adjust as needed)
data_swire_copy['year_month'] = data_swire_copy['EXECUTION_START_DATE'].dt.to_period('M')  # Month-wise aggregation
mtbf_over_time = data_swire_copy.groupby('year_month')['time_since_last_failure'].mean()

# Plot MTBF over time
plt.figure(figsize=(12, 6))
mtbf_over_time.plot(kind='line', marker='o', color='blue')
plt.title("Mean Time Between Failures (MTBF) Over Time")
plt.xlabel("Year-Month")
plt.ylabel("Average MTBF (Days)")
plt.xticks(rotation=45)
plt.grid()
plt.show()

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# 1. Breakdown Frequency by Machine
machine_breakdowns = data_swire_copy['EQUIPMENT_ID'].value_counts()

# Plot breakdown frequency by machine (Top 10 machines)
plt.figure(figsize=(12, 6))
machine_breakdowns.head(10).plot(kind='bar', color='skyblue')
plt.title("Top 10 Machines with Most Breakdowns")
plt.xlabel("Machine ID")
plt.ylabel("Breakdown Count")
plt.show()

# 2. Mean Time Between Failures (MTBF) Calculation
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])
data_swire_copy['time_between_failures'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days
mtbf_per_machine = data_swire_copy.groupby('EQUIPMENT_ID')['time_between_failures'].mean()

# Plot MTBF for top 10 machines with the highest breakdown frequency
top_machines = machine_breakdowns.head(10).index
mtbf_top_machines = mtbf_per_machine[top_machines].dropna()

plt.figure(figsize=(12, 6))
mtbf_top_machines.plot(kind='bar', color='lightgreen')
plt.title("Mean Time Between Failures (MTBF) for Top 10 Machines")
plt.xlabel("Machine ID")
plt.ylabel("Average Days Between Failures")
plt.show()

# 3. Breakdown Distribution by Type and Cause
# Assuming 'MAINTENANCE_TYPE_DESCRIPTION' (corrective/preventive) and 'ORDER_DESCRIPTION' (description of cause) columns exist
breakdown_type_counts = data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'].value_counts()
cause_counts = data_swire_copy['ORDER_DESCRIPTION'].value_counts().head(10)

# Plot breakdowns by type and top 10 causes
plt.figure(figsize=(14, 6))

plt.subplot(1, 2, 1)
breakdown_type_counts.plot(kind='bar', color='coral')
plt.title("Breakdown Distribution by Maintenance Type")
plt.xlabel("Maintenance Type")
plt.ylabel("Count")

plt.subplot(1, 2, 2)
cause_counts.plot(kind='bar', color='salmon')
plt.title("Top 10 Breakdown Causes")
plt.xlabel("Cause Description")
plt.ylabel("Count")
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# 4. Temporal Breakdown Analysis (Monthly, Day of the Week, Hourly Patterns)
# Monthly breakdown pattern
data_swire_copy['year_month'] = data_swire_copy['EXECUTION_START_DATE'].dt.to_period('M')
monthly_breakdowns = data_swire_copy.groupby('year_month').size()
monthly_breakdowns.index = monthly_breakdowns.index.to_timestamp()

plt.figure(figsize=(12, 6))
monthly_breakdowns.plot(color='steelblue')
plt.title("Monthly Breakdown Pattern")
plt.xlabel("Month")
plt.ylabel("Breakdown Count")
plt.show()

# Day of the week pattern
data_swire_copy['day_of_week'] = data_swire_copy['EXECUTION_START_DATE'].dt.day_name()
dow_breakdowns = data_swire_copy['day_of_week'].value_counts().reindex(
    ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
)

plt.figure(figsize=(10, 5))
dow_breakdowns.plot(kind='bar', color='mediumpurple')
plt.title("Breakdowns by Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Breakdown Count")
plt.show()

# Hourly breakdown pattern
data_swire_copy['hour_of_day'] = data_swire_copy['EXECUTION_START_DATE'].dt.hour
hourly_breakdowns = data_swire_copy['hour_of_day'].value_counts().sort_index()

plt.figure(figsize=(10, 5))
hourly_breakdowns.plot(kind='bar', color='mediumseagreen')
plt.title("Breakdowns by Hour of the Day")
plt.xlabel("Hour of the Day")
plt.ylabel("Breakdown Count")
plt.show()

# Ensure EXECUTION_START_DATE is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Extract month from EXECUTION_START_DATE
data_swire_copy['Month'] = data_swire_copy['EXECUTION_START_DATE'].dt.month

# Count breakdowns or maintenance activities by month
monthly_breakdowns = data_swire_copy.groupby('Month').size()

# Plotting the breakdown counts per month
plt.figure(figsize=(10, 6))
monthly_breakdowns.plot(kind='bar', color='skyblue')
plt.title('Maintenance Activities per Month (All Years Combined)')
plt.xlabel('Month')
plt.ylabel('Count of Maintenance Activities')
plt.xticks(ticks=range(0, 12), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], rotation=45)

# Annotate counts on each bar
for index, value in enumerate(monthly_breakdowns):
    plt.text(index, value, str(value), ha='center', va='bottom')

plt.tight_layout()
plt.show()

# Display which month has the highest number of breakdowns
max_breakdown_month = monthly_breakdowns.idxmax()
max_breakdown_count = monthly_breakdowns.max()
print(f"The month with the highest breakdowns is: {max_breakdown_month} with {max_breakdown_count} activities.")

The month with the highest breakdowns is: 5 with 18746 activities.

# Ensure the date column is in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])

# Group data by maintenance type and month without setting the index
monthly_counts_by_type = data_swire_copy.groupby([pd.Grouper(key='EXECUTION_START_DATE', freq='M'), 'MAINTENANCE_TYPE_DESCRIPTION']).size().unstack(fill_value=0)

# Plotting time series for each maintenance type
plt.figure(figsize=(14, 8))
monthly_counts_by_type.plot(ax=plt.gca(), linewidth=2)

# Adding title and labels
plt.title('Monthly Maintenance Events by Maintenance Type')
plt.xlabel('Date')
plt.ylabel('Number of Maintenance Events')
plt.legend(title='Maintenance Type Description')
plt.tight_layout()
plt.show()

C:\Users\u1478229\AppData\Local\Temp\ipykernel_7708\3538187986.py:5: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.
  monthly_counts_by_type = data_swire_copy.groupby([pd.Grouper(key='EXECUTION_START_DATE', freq='M'), 'MAINTENANCE_TYPE_DESCRIPTION']).size().unstack(fill_value=0)

# Calculate a 3-month rolling average for each maintenance type
rolling_avg_by_type = monthly_counts_by_type.rolling(window=3).mean()

# Plotting the rolling average for each maintenance type
plt.figure(figsize=(14, 8))
rolling_avg_by_type.plot(ax=plt.gca(), linewidth=2)

# Adding title and labels
plt.title('3-Month Rolling Average of Maintenance Events by Maintenance Type')
plt.xlabel('Date')
plt.ylabel('Average Number of Maintenance Events')
plt.legend(title='Maintenance Type Description')
plt.tight_layout()
plt.show()

work_orders_by_plant_machine = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID']).agg(
    work_order_count=('ORDER_ID', 'count')
).reset_index()

# Display aggregated data
print("Aggregated Work Orders by Plant and Machine:")
print(work_orders_by_plant_machine)

# Aggregating work orders by plant and equipment category
work_orders_by_plant_category = data_swire_copy.groupby(['PLANT_ID', 'EQUIP_CAT_DESC']).agg(
    work_order_count=('ORDER_ID', 'count')
).reset_index()

print("\nAggregated Work Orders by Plant and Equipment Category:")
print(work_orders_by_plant_category)

# Optional: Aggregating work orders by plant, machine, and year if EXECUTION_START_DATE is available
if 'EXECUTION_START_DATE' in data_swire_copy.columns:
    data_swire_copy['EXECUTION_YEAR'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE']).dt.year
    work_orders_by_plant_machine_year = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID', 'EXECUTION_YEAR']).agg(
        work_order_count=('ORDER_ID', 'count')
    ).reset_index()

    print("\nAggregated Work Orders by Plant, Machine, and Year:")
    print(work_orders_by_plant_machine_year)

# Additional aggregations such as total downtime (if a downtime column is available)
if 'ACTUAL_WORK_IN_MINUTES' in data_swire_copy.columns:
    downtime_by_plant_machine = data_swire_copy.groupby(['PLANT_ID', 'EQUIPMENT_ID']).agg(
        total_downtime=('ACTUAL_WORK_IN_MINUTES', 'sum'),
        avg_downtime=('ACTUAL_WORK_IN_MINUTES', 'mean')
    ).reset_index()

    print("\nDowntime Aggregation by Plant and Machine:")
    print(downtime_by_plant_machine)

Aggregated Work Orders by Plant and Machine:
     PLANT_ID  EQUIPMENT_ID  work_order_count
0        G221   300009071.0                47
1        G221   300009072.0                21
2        G221   300009073.0                 3
3        G221   300009074.0                77
4        G221   300009075.0                40
...       ...           ...               ...
2218     G816   400003848.0                 1
2219     G816   400017600.0                23
2220     G816   400022400.0                 4
2221     G816   400027400.0                36
2222     G816   400027800.0                 3

[2223 rows x 3 columns]

Aggregated Work Orders by Plant and Equipment Category:
   PLANT_ID              EQUIP_CAT_DESC  work_order_count
0      G221                    Machines               153
1      G221           Plant & Buildings                24
2      G261                    Machines              1368
3      G291                    Machines             34899
4      G291           Plant & Buildings                 4
5      G291  Production resources/tools                73
6      G811                    Machines              2554
7      G811           Plant & Buildings                12
8      G811  Test/measurement equipment                 2
9      G812                    Machines              2777
10     G816                    Machines             10747
11     G816  Test/measurement equipment                43

Aggregated Work Orders by Plant, Machine, and Year:
      PLANT_ID  EQUIPMENT_ID  EXECUTION_YEAR  work_order_count
0         G221   300009071.0            2017                 3
1         G221   300009071.0            2018                 7
2         G221   300009071.0            2019                 6
3         G221   300009071.0            2020                 8
4         G221   300009071.0            2021                 6
...        ...           ...             ...               ...
10007     G816   400027400.0            2022                 8
10008     G816   400027400.0            2023                16
10009     G816   400027400.0            2024                12
10010     G816   400027800.0            2022                 1
10011     G816   400027800.0            2023                 2

[10012 rows x 4 columns]

Downtime Aggregation by Plant and Machine:
     PLANT_ID  EQUIPMENT_ID  total_downtime  avg_downtime
0        G221   300009071.0          2895.6     61.608511
1        G221   300009072.0          2210.4    105.257143
2        G221   300009073.0           580.2    193.400000
3        G221   300009074.0          5337.6     69.319481
4        G221   300009075.0          3801.0     95.025000
...       ...           ...             ...           ...
2218     G816   400003848.0            12.0     12.000000
2219     G816   400017600.0          1614.0     70.173913
2220     G816   400022400.0           270.0     67.500000
2221     G816   400027400.0          2118.0     58.833333
2222     G816   400027800.0            36.0     12.000000

[2223 rows x 4 columns]

import matplotlib.pyplot as plt

# Define the functional nodes columns to analyze
functional_nodes = [
    'FUNCTIONAL_AREA_NODE_1_MODIFIED',
    'FUNCTIONAL_AREA_NODE_2_MODIFIED',
    'FUNCTIONAL_AREA_NODE_3_MODIFIED',
    'FUNCTIONAL_AREA_NODE_4_MODIFIED',
    'FUNCTIONAL_AREA_NODE_5_MODIFIED'
]

# Loop through each functional node column
for node in functional_nodes:
    # Count occurrences of each unique value in the node column
    node_counts = data_swire_copy[node].value_counts()

    # Filter to show only values that appear more than once (repeated entries)
    repeated_node = node_counts[node_counts > 1]

    # Plotting the repeated entries as a bar plot
    plt.figure(figsize=(12, 8))
    repeated_node.plot(kind='bar', color='skyblue')
    plt.title(f'Repeated Entries in {node}')
    plt.xlabel(node)
    plt.ylabel('Count')
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()
    plt.show()

# Calculate counts for different maintenance types in unplanned activities
corrective_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Corrective Maintenance Order')
].shape[0]

preventive_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Preventive Maintenance Order')
].shape[0]

capital_order_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Capital Order')
].shape[0]

breakdown_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Breakdown Maintenance Order')
].shape[0]

administrative_unplanned_count = data_swire_copy[
    (data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned') &
    (data_swire_copy['MAINTENANCE_TYPE_DESCRIPTION'] == 'Administrative Order')
].shape[0]

# Print results
print(f"Number of corrective maintenance orders in unplanned activities: {corrective_unplanned_count}")
print(f"Number of preventive maintenance orders in unplanned activities: {preventive_unplanned_count}")
print(f"Number of capital orders in unplanned activities: {capital_order_unplanned_count}")
print(f"Number of breakdown orders in unplanned activities: {breakdown_unplanned_count}")
print(f"Number of administrative orders in unplanned activities: {administrative_unplanned_count}")

Number of corrective maintenance orders in unplanned activities: 94618
Number of preventive maintenance orders in unplanned activities: 812
Number of capital orders in unplanned activities: 16
Number of breakdown orders in unplanned activities: 3
Number of administrative orders in unplanned activities: 4541

# Ensure date columns are in datetime format
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'])
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'])

# Sort data by EQUIPMENT_DESC and EXECUTION_START_DATE
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_DESC', 'EXECUTION_START_DATE'])

# Calculate time between failures in hours
data_swire_copy['Time_Between_Failures'] = data_swire_copy.groupby('EQUIPMENT_DESC')['EXECUTION_START_DATE'].diff().dt.total_seconds() / 3600

# Remove rows where time between failures is NaN (first occurrence for each equipment)
data_swire_copy = data_swire_copy.dropna(subset=['Time_Between_Failures'])

# Filter top 10 equipment types by frequency
top_10_equipment = data_swire_copy['EQUIPMENT_DESC'].value_counts().nlargest(10).index
top_10_data = data_swire_copy[data_swire_copy['EQUIPMENT_DESC'].isin(top_10_equipment)]

# Plot density plots for the top 10 equipment types
fig, axes = plt.subplots(5, 2, figsize=(15, 15), constrained_layout=True)  # Adjust layout for 10 plots (5 rows, 2 columns)
axes = axes.flatten()

for ax, equipment in zip(axes, top_10_equipment):
    sns.kdeplot(
        data=top_10_data[top_10_data['EQUIPMENT_DESC'] == equipment]['Time_Between_Failures'],
        fill=True,
        color="salmon",
        ax=ax
    )
    ax.set_title(equipment)
    ax.set_xlabel("Time Between Failures [Hours]")
    ax.set_ylabel("Density")

plt.show()

# Calculate maintenance frequency and average downtime for each node
maintenance_patterns = data_swire_copy.groupby(['FUNCTIONAL_AREA_NODE_1_MODIFIED', 'FUNCTIONAL_AREA_NODE_2_MODIFIED',
                                                'FUNCTIONAL_AREA_NODE_3_MODIFIED', 'FUNCTIONAL_AREA_NODE_4_MODIFIED',
                                                'FUNCTIONAL_AREA_NODE_5_MODIFIED'])['ACTUAL_WORK_IN_MINUTES'] \
                                       .agg(['count', 'mean']).reset_index()

maintenance_patterns.rename(columns={'count': 'Maintenance_Frequency', 'mean': 'Average_Downtime'}, inplace=True)

# Sort by Maintenance_Frequency and Average_Downtime in descending order
high_maintenance_areas = maintenance_patterns.sort_values(by=['Maintenance_Frequency', 'Average_Downtime'], ascending=False)

# Reset the index to have a clean ordered index
high_maintenance_areas.reset_index(drop=True, inplace=True)


high_maintenance_areas.head(10)

# Ensure datetime conversion and remove rows with invalid dates
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Filter for planned maintenance events and create a copyD
planned_maintenance = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned'].copy()

# Sort by EQUIPMENT_ID and EXECUTION_START_DATE to compute time intervals between events
planned_maintenance = planned_maintenance.sort_values(['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference between consecutive planned maintenance events for each machine
planned_maintenance['Maintenance_Interval_Days'] = planned_maintenance.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Calculate the average maintenance interval (in days) for each machine
maintenance_frequency = planned_maintenance.groupby('EQUIPMENT_ID')['Maintenance_Interval_Days'].mean().dropna()

# Convert the frequency to weeks for easier interpretation
maintenance_frequency_weeks = maintenance_frequency / 7

# Display the maintenance frequency in both days and weeks for the top 10 machines
top_machines = maintenance_frequency.sort_values(ascending=True)  # Top 10 machines with shortest average intervals
top_machines_weeks = maintenance_frequency_weeks[top_machines.index]

# Create a DataFrame to display the results
frequency_df = pd.DataFrame({
    'Average_Interval_Days': top_machines,
    'Average_Interval_Weeks': top_machines_weeks
})

frequency_df

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Calculate the time difference (in days) between consecutive failures for each machine
data_swire_copy['time_between_failures'] = data_swire_copy.groupby('EQUIPMENT_ID')['EXECUTION_START_DATE'].diff().dt.days

# Calculate breakdown count and MTBF (Mean Time Between Failures) for each machine
breakdown_count = data_swire_copy['EQUIPMENT_ID'].value_counts()
mtbf_per_machine = data_swire_copy.groupby('EQUIPMENT_ID')['time_between_failures'].mean()

# Define risk thresholds
# High breakdown count threshold (top 10%)
breakdown_threshold = breakdown_count.quantile(0.9)

# Short MTBF threshold (bottom 10% of MTBF)
mtbf_threshold = mtbf_per_machine.quantile(0.1)

# Create a risk assessment table
risk_table = pd.DataFrame({
    'Breakdown_Count': breakdown_count,
    'Average_MTBF_Days': mtbf_per_machine
})

# Determine risk status based on thresholds
risk_table['Risk_Status'] = risk_table.apply(
    lambda row: 'At Risk' if (row['Breakdown_Count'] >= breakdown_threshold) or
                                (row['Average_MTBF_Days'] <= mtbf_threshold) else 'Low Risk', axis=1
)

# Sort the at-risk equipment by Breakdown Count and Average MTBF in descending order
# and display the top 10 entries
at_risk_equipments = risk_table[risk_table['Risk_Status'] == 'At Risk']
top_10_at_risk_equipments = at_risk_equipments.sort_values(
    by=['Breakdown_Count', 'Average_MTBF_Days'],
    ascending=[False, True]  # Sorting by highest breakdowns and shortest MTBF
).head(10)

# Reset index for a clean display
top_10_at_risk_equipments.reset_index().rename(columns={'index': 'Equipment_ID'}, inplace=True)

# Display the top 10 at-risk equipment
print(top_10_at_risk_equipments)

              Breakdown_Count  Average_MTBF_Days Risk_Status
EQUIPMENT_ID                                                
300115000.0              3743           0.476750     At Risk
300001113.0              2736           0.998537     At Risk
300001078.0              1851           1.473514     At Risk
300001276.0              1574           1.736173     At Risk
300001509.0              1472           1.850442     At Risk
300001580.0              1470           1.855003     At Risk
300033692.0              1178           2.063721     At Risk
300111000.0              1064           1.712135     At Risk
300001560.0               929           2.929957     At Risk
300074802.0               911           2.349451     At Risk

data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])

# Sort data by machine and by date
data_swire_copy = data_swire_copy.sort_values(by=['EQUIPMENT_ID', 'EXECUTION_START_DATE'])

# Filter for planned maintenance and unplanned downtime events
planned_maintenance = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Planned']
unplanned_downtime = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'] == 'Unplanned']

# Calculate the time between each planned maintenance and the next unplanned downtime for each machine
maintenance_intervals = []

for equipment_id in planned_maintenance['EQUIPMENT_ID'].unique():
    # Filter events for the specific machine
    machine_maintenance = planned_maintenance[planned_maintenance['EQUIPMENT_ID'] == equipment_id]
    machine_downtime = unplanned_downtime[unplanned_downtime['EQUIPMENT_ID'] == equipment_id]

    # Loop through each maintenance event
    for maintenance_date in machine_maintenance['EXECUTION_START_DATE']:
        # Find the next unplanned downtime after each maintenance
        next_downtime = machine_downtime[machine_downtime['EXECUTION_START_DATE'] > maintenance_date]

        if not next_downtime.empty:
            time_to_next_downtime = (next_downtime['EXECUTION_START_DATE'].iloc[0] - maintenance_date).days
            maintenance_intervals.append({'EQUIPMENT_ID': equipment_id, 'maintenance_date': maintenance_date, 'time_to_next_downtime': time_to_next_downtime})

# Create a DataFrame to analyze maintenance intervals
maintenance_intervals_df = pd.DataFrame(maintenance_intervals)

# Calculate average time to next downtime after maintenance for each machine
avg_time_to_downtime = maintenance_intervals_df.groupby('EQUIPMENT_ID')['time_to_next_downtime'].mean()

# Plot average time to next downtime after maintenance for each machine
# Plot histogram of average time to next downtime
plt.figure(figsize=(10, 6))
plt.hist(avg_time_to_downtime, bins=20, color='lightgreen', edgecolor='black')
plt.title("Histogram of Average Time to Next Downtime After Maintenance")
plt.xlabel("Average Days to Next Downtime")
plt.ylabel("Number of Machines")
plt.show()

top_machines = avg_time_to_downtime.sort_values(ascending=False).head(10)

# Plot top 10 machines
plt.figure(figsize=(10, 6))
top_machines.plot(kind='bar', color='skyblue')
plt.title("Top 10 Machines with Longest Average Time to Next Downtime After Maintenance")
plt.xlabel("Machine ID")
plt.ylabel("Average Days to Next Downtime")
plt.xticks(rotation=45)
plt.show()

# Define seasons based on 'EXECUTION_FINISH_DATE'
# Define cost per minute
cost_per_minute = 8.33  # Adjust this value based on actual cost

# Calculate downtime cost
data_swire_copy['downtime_cost'] = data_swire_copy['ACTUAL_WORK_IN_MINUTES'] * cost_per_minute

data_swire_copy['season'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month % 12 // 3 + 1  # 1=Winter, 2=Spring, etc.
season_labels = {1: "Winter", 2: "Spring", 3: "Summer", 4: "Fall"}

# Calculate total downtime cost per season
seasonal_downtime_cost = data_swire_copy.groupby('season')['downtime_cost'].sum().rename(index=season_labels)
print("Total Downtime Cost by Season:")
print(seasonal_downtime_cost)

# Plot downtime costs by season
seasonal_downtime_cost.plot(kind='bar', color='skyblue')
plt.title("Total Downtime Cost by Season")
plt.xlabel("Season")
plt.ylabel("Downtime Cost ($)")
plt.xticks(rotation=45)
plt.grid(True)
plt.show()

Total Downtime Cost by Season:
season
Winter    6701738.232
Spring    9305216.424
Summer    8924643.714
Fall      6371880.228
Name: downtime_cost, dtype: float64

# Ensure the date column is in datetime format
data_swire_copy['EXECUTION_FINISH_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_FINISH_DATE'], errors='coerce')

# Extract the month from the date column
data_swire_copy['month'] = data_swire_copy['EXECUTION_FINISH_DATE'].dt.month

# Calculate total downtime cost per month
monthly_downtime_cost = data_swire_copy.groupby('month')['downtime_cost'].sum()

# Display the month-wise downtime costs
print(monthly_downtime_cost)

# Plot month-wise downtime cost
plt.figure(figsize=(10, 6))
monthly_downtime_cost.plot(kind='bar', color='skyblue')
plt.title("Total Downtime Cost by Month")
plt.xlabel("Month")
plt.ylabel("Downtime Cost ($)")
plt.xticks(ticks=range(12), labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

month
1     2212914.480
2     2336939.850
3     3078862.962
4     3066597.870
5     3159755.592
6     3121870.752
7     2870831.208
8     2931941.754
9     2002293.762
10    2165698.374
11    2203888.092
12    2151883.902
Name: downtime_cost, dtype: float64

# Define the feature columns and target column
X = data_swire_copy[['MAINTENANCE_TYPE_DESCRIPTION', 'PRODUCTION_LOCATION', 'FUNCTIONAL_LOC']]
y = data_swire_copy['ACTUAL_WORK_IN_MINUTES']

# Split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Define preprocessing for categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(handle_unknown='ignore'), ['MAINTENANCE_TYPE_DESCRIPTION', 'PRODUCTION_LOCATION', 'FUNCTIONAL_LOC'])
    ])

# Create a pipeline that combines preprocessing and model
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('model', RandomForestRegressor(n_estimators=100, random_state=42))
])

# Train the model
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
print("Mean Absolute Error:", mae)
print("Mean Squared Error:", mse)

# Feature Importance (for Random Forest)
importances = pipeline.named_steps['model'].feature_importances_
feature_names = pipeline.named_steps['preprocessor'].transformers_[0][1].get_feature_names_out()
feature_importances = pd.Series(importances, index=feature_names).sort_values(ascending=False)
print("Top Features:")
feature_importances.head(10)

feature_importances.head(10).plot(kind='barh', color='skyblue')
plt.title("Top Feature Importances for Downtime Prediction")
plt.xlabel("Importance")
plt.show()

Mean Absolute Error: 52.194036836484024
Mean Squared Error: 18299.018017527607
Top Features:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import pandas as pd

# Define features (X) and target (y)
features = ['PLANT_ID', 'MAINTENANCE_PLAN', 'EQUIPMENT_ID', 'time_since_last_failure']  # Add relevant columns
target = 'ACTUAL_WORK_IN_MINUTES'

# Drop rows with missing target values
data_reg = data_swire_copy.dropna(subset=[target])

# Select features and fill missing values in predictors with 0 (or use an imputation method)
X = data_reg[features].fillna(0)
y = data_reg[target]

# One-hot encode categorical columns if any
X = pd.get_dummies(X, drop_first=True)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the linear regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Predict and evaluate the model
y_pred = model.predict(X_test)

print("Model Evaluation:")
print(f"Mean Absolute Error (MAE): {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Mean Squared Error (MSE): {mean_squared_error(y_test, y_pred):.2f}")
print(f"R2 Score: {r2_score(y_test, y_pred):.4f}")

# View coefficients
coefficients = pd.DataFrame({'Feature': X.columns, 'Coefficient': model.coef_})
print("\nFeature Coefficients:")
print(coefficients)

Model Evaluation:
Mean Absolute Error (MAE): 161.00
Mean Squared Error (MSE): 134085920.30
R2 Score: -6358.5804

Feature Coefficients:
                         Feature   Coefficient
0                   EQUIPMENT_ID  3.564520e-07
1        time_since_last_failure -1.099073e-02
2                  PLANT_ID_G261 -9.999312e+00
3                  PLANT_ID_G291  7.147221e-01
4                  PLANT_ID_G811  2.148204e+01
..                           ...           ...
774  MAINTENANCE_PLAN_G816SC1485 -4.330528e+01
775  MAINTENANCE_PLAN_G816SC1487  8.766411e+00
776  MAINTENANCE_PLAN_G816SC5005 -4.554018e+01
777  MAINTENANCE_PLAN_G816SC5038 -2.703412e+01
778  MAINTENANCE_PLAN_G816SC5039  7.267372e+01

[779 rows x 2 columns]

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import pandas as pd

# Prepare the dataset
features = ['PLANT_ID', 'MAINTENANCE_PLAN', 'EQUIPMENT_ID', 'time_since_last_failure']
target = 'ACTUAL_WORK_IN_MINUTES'

# Drop rows with missing target values
data_rf = data_swire_copy.dropna(subset=[target])

# Select features and target
X = data_rf[features].fillna(0)
y = data_rf[target]

# One-hot encode categorical variables
X = pd.get_dummies(X, drop_first=True)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the Random Forest model
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Predict and evaluate
y_pred = rf_model.predict(X_test)

print("Random Forest Model Evaluation:")
print(f"Mean Absolute Error (MAE): {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Mean Squared Error (MSE): {mean_squared_error(y_test, y_pred):.2f}")
print(f"R2 Score: {r2_score(y_test, y_pred):.4f}")

# Feature Importance
feature_importances = pd.DataFrame({
    'Feature': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

print("\nTop Features by Importance:")
print(feature_importances.head(10))

Random Forest Model Evaluation:
Mean Absolute Error (MAE): 53.40
Mean Squared Error (MSE): 20299.96
R2 Score: 0.0372

Top Features by Importance:
                           Feature  Importance
1          time_since_last_failure    0.366666
0                     EQUIPMENT_ID    0.187973
232     MAINTENANCE_PLAN_G29160028    0.070734
233     MAINTENANCE_PLAN_G29160029    0.044272
234     MAINTENANCE_PLAN_G29160030    0.035114
82      MAINTENANCE_PLAN_G29110997    0.018567
687  MAINTENANCE_PLAN_G811LTQA0002    0.008268
7    MAINTENANCE_PLAN_000000013534    0.007381
2                    PLANT_ID_G261    0.006809
4                    PLANT_ID_G811    0.005260

from xgboost import XGBRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import pandas as pd

# Step 1: Prepare the dataset
features = ['PLANT_ID', 'MAINTENANCE_PLAN', 'EQUIPMENT_ID', 'time_since_last_failure']  # Add more relevant columns
target = 'ACTUAL_WORK_IN_MINUTES'

# Drop rows with missing target values
data_xgb = data_swire_copy.dropna(subset=[target])

# Select features and target
X = data_xgb[features].fillna(0)
y = data_xgb[target]

# One-hot encode categorical variables
X = pd.get_dummies(X, drop_first=True)

# Step 2: Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Step 3: Train the XGBoost model
xgb_model = XGBRegressor(n_estimators=100, learning_rate=0.1, random_state=42)
xgb_model.fit(X_train, y_train)

# Step 4: Predict and evaluate
y_pred = xgb_model.predict(X_test)

print("XGBoost Model Evaluation:")
print(f"Mean Absolute Error (MAE): {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Mean Squared Error (MSE): {mean_squared_error(y_test, y_pred):.2f}")
print(f"R2 Score: {r2_score(y_test, y_pred):.4f}")

# Feature Importance
feature_importances = pd.DataFrame({
    'Feature': X.columns,
    'Importance': xgb_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

print("\nTop Features by Importance:")
print(feature_importances.head(10))

XGBoost Model Evaluation:
Mean Absolute Error (MAE): 52.86
Mean Squared Error (MSE): 18454.12
R2 Score: 0.1247

Top Features by Importance:
                           Feature  Importance
232     MAINTENANCE_PLAN_G29160028    0.153451
233     MAINTENANCE_PLAN_G29160029    0.082115
234     MAINTENANCE_PLAN_G29160030    0.081236
82      MAINTENANCE_PLAN_G29110997    0.049407
5                    PLANT_ID_G812    0.032175
2                    PLANT_ID_G261    0.025014
7    MAINTENANCE_PLAN_000000013534    0.024253
0                     EQUIPMENT_ID    0.023495
687  MAINTENANCE_PLAN_G811LTQA0002    0.022113
4                    PLANT_ID_G811    0.017649

import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import pandas as pd

# Prepare the dataset
features = ['PLANT_ID', 'MAINTENANCE_PLAN', 'EQUIPMENT_ID', 'time_since_last_failure']  # Add relevant features
target = 'ACTUAL_WORK_IN_MINUTES'

# Drop rows with missing target values
data_lgb = data_swire_copy.dropna(subset=[target])

# Select features and target
X = data_lgb[features].fillna(0)  # Fill missing values
y = data_lgb[target]

# One-hot encode categorical variables
X = pd.get_dummies(X, drop_first=True)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Prepare LightGBM Dataset
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# Set LightGBM parameters
params = {
    'objective': 'regression',
    'metric': 'rmse',
    'boosting_type': 'gbdt',
    'num_leaves': 31,  # Controls the complexity of the tree
    'learning_rate': 0.1,
    'feature_fraction': 0.8,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': -1
}

# Train the LightGBM model with early stopping callback
callbacks = [lgb.early_stopping(stopping_rounds=10, verbose=True)]
lgb_model = lgb.train(params, train_data, num_boost_round=100, valid_sets=[test_data], callbacks=callbacks)

# Predict and evaluate
y_pred = lgb_model.predict(X_test, num_iteration=lgb_model.best_iteration)

# Model evaluation
print("LightGBM Model Evaluation:")
print(f"Mean Absolute Error (MAE): {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Mean Squared Error (MSE): {mean_squared_error(y_test, y_pred):.2f}")
print(f"R2 Score: {r2_score(y_test, y_pred):.4f}")

# Feature Importance
importance = lgb_model.feature_importance()
feature_names = X.columns
feature_importance = pd.DataFrame({'Feature': feature_names, 'Importance': importance})
feature_importance = feature_importance.sort_values(by='Importance', ascending=False)

print("\nTop Features by Importance:")
print(feature_importance.head(10))

# Plot Feature Importance
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 6))
plt.barh(feature_importance['Feature'].head(10), feature_importance['Importance'].head(10))
plt.gca().invert_yaxis()
plt.title('Top 10 Feature Importances')
plt.show()

Training until validation scores don't improve for 10 rounds
Early stopping, best iteration is:
[31]	valid_0's rmse: 134.229
LightGBM Model Evaluation:
Mean Absolute Error (MAE): 52.18
Mean Squared Error (MSE): 18017.39
R2 Score: 0.1455

Top Features by Importance:
                           Feature  Importance
0                     EQUIPMENT_ID         236
1          time_since_last_failure         150
233     MAINTENANCE_PLAN_G29160029          35
232     MAINTENANCE_PLAN_G29160028          26
234     MAINTENANCE_PLAN_G29160030          25
82      MAINTENANCE_PLAN_G29110997          20
7    MAINTENANCE_PLAN_000000013534          17
12   MAINTENANCE_PLAN_000000022943          16
620    MAINTENANCE_PLAN_G291VM5012          14
626    MAINTENANCE_PLAN_G291VM5029          14

# Splitting the 'FUNCTIONAL_LOC' column into separate node columns
data_swire_copy[['Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']] = data_swire_copy['FUNCTIONAL_LOC'].str.split('-', expand=True)

# Display the first few rows to check the split
print(data_swire_copy[['FUNCTIONAL_LOC', 'Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']].head())

# Creating flag columns to indicate the presence of each node
# If a column has a value, it is flagged as 1 (present), otherwise 0 (absent)
data_swire_copy['Plant_Flag'] = data_swire_copy['Plant'].notnull().astype(int)
data_swire_copy['Process_Flag'] = data_swire_copy['Process'].notnull().astype(int)
data_swire_copy['Sub_Process_Flag'] = data_swire_copy['Sub_Process'].notnull().astype(int)
data_swire_copy['Product_Line_Flag'] = data_swire_copy['Product_Line'].notnull().astype(int)
data_swire_copy['Machine_Flag'] = data_swire_copy['Machine'].notnull().astype(int)
data_swire_copy['Sub_Machine_Flag'] = data_swire_copy['Sub_Machine'].notnull().astype(int)

# Display the updated DataFrame structure
print("\nUpdated DataFrame with flags:")
print(data_swire_copy[['Plant', 'Plant_Flag', 'Process', 'Process_Flag', 'Sub_Process', 'Sub_Process_Flag']].head())

              FUNCTIONAL_LOC Plant Process Sub_Process Product_Line Machine  \
0  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
1  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
2  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
3  G812-PRD-L15-L03-L030-020  G812     PRD         L15          L03    L030   
4               G291-PRD-P05  G291     PRD         P05         None    None   

  Sub_Machine  
0         020  
1         020  
2         020  
3         020  
4        None  

Updated DataFrame with flags:
  Plant  Plant_Flag Process  Process_Flag Sub_Process  Sub_Process_Flag
0  G812           1     PRD             1         L15                 1
1  G812           1     PRD             1         L15                 1
2  G812           1     PRD             1         L15                 1
3  G812           1     PRD             1         L15                 1
4  G291           1     PRD             1         P05                 1

# Checking unique values in 'MAINTENANCE_ACTIVITY_TYPE' to understand the categories
print("Unique values in 'MAINTENANCE_ACTIVITY_TYPE':")
print(data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].unique())

# Assuming that 'Planned' and 'Unplanned' are identifiable in the 'MAINTENANCE_ACTIVITY_TYPE' column
# Replace 'Planned' and 'Unplanned' with the actual values from the dataset that represent these activities

# Filtering planned maintenance data
planned_data = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Planned', case=False, na=False)]

# Filtering unplanned maintenance data
unplanned_data = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Display the counts for verification
print(f"Number of unplanned maintenance records: {len(unplanned_data)}")

# Display first few rows of unplanned dataset for confirmation
print("\nFirst few rows of unplanned data:")
print(unplanned_data.head())

Unique values in 'MAINTENANCE_ACTIVITY_TYPE':
['Unplanned' 'Planned']
Number of unplanned maintenance records: 1276877

First few rows of unplanned data:
    ORDER_ID PLANT_ID PRODUCTION_LOCATION EXECUTION_START_DATE  \
0  705642457     G812                ROMA           2024-05-04   
1  704191697     G812                ROMA           2022-09-13   
2  704466547     G812                ROMA           2022-12-21   
3  703834477     G812                ROMA           2022-07-04   
4  704661125     G291               MONZA           2023-03-15   

  EXECUTION_FINISH_DATE ACTUAL_START_TIME ACTUAL_FINISH_TIME  \
0            2024-05-12      06:00:00.000       23:04:08.000   
1            2022-09-13      06:00:00.000       17:17:24.000   
2            2022-12-21      07:00:00.000       07:00:00.000   
3            2022-07-04      06:00:00.000       06:00:00.000   
4            2023-03-15      07:00:00.000       07:00:00.000   

   ACTUAL_WORK_IN_MINUTES MAINTENANCE_PLAN  MAINTENANCE_ITEM  ...  \
0                   390.0              NaN               NaN  ...   
1                   420.0              NaN               NaN  ...   
2                    30.0              NaN               NaN  ...   
3                    60.0              NaN               NaN  ...   
4                   120.0              NaN               NaN  ...   

  FUNCTIONAL_AREA_NODE_2_MODIFIED    FUNCTIONAL_AREA_NODE_3_MODIFIED  \
0      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
1      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
2      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
3      G812 PRD FILLER_ROTARY_CAN  G812 PRD FILLER_ROTARY_CAN LINE 3   
4                     AIR SYSTEMS                                NaN   

  FUNCTIONAL_AREA_NODE_4_MODIFIED FUNCTIONAL_AREA_NODE_5_MODIFIED  \
0                        CONVEYOR               FULL CAN CONVEYOR   
1                        CONVEYOR               FULL CAN CONVEYOR   
2                        CONVEYOR               FULL CAN CONVEYOR   
3                        CONVEYOR               FULL CAN CONVEYOR   
4                             NaN                             NaN   

  EQUIPMENT_ID             EQUIPMENT_DESC EQUIP_CAT_DESC EQUIP_START_UP_DATE  \
0  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
1  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
2  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
3  300126812.0  FULL CAN CONVEYOR (FC41B)       Machines          2020-04-22   
4  300001088.0          TANK_STL_STOR_AIR       Machines          2017-02-15   

  EQUIP_VALID_FROM  EQUIP_VALID_TO  
0       2020-02-10      9999-12-31  
1       2020-02-10      9999-12-31  
2       2020-02-10      9999-12-31  
3       2020-02-10      9999-12-31  
4       2023-12-11      9999-12-31  

[5 rows x 25 columns]

# Filter for unplanned maintenance data
df_unplanned = data_swire_copy[data_swire_copy['MAINTENANCE_ACTIVITY_TYPE'].str.contains('Unplanned', case=False, na=False)]

# Filter rows where parts have been replaced based on the 'ORDER_DESCRIPTION' column
replace_rows = df_unplanned[df_unplanned['ORDER_DESCRIPTION'].str.contains('replace', case=False, na=False)]

# Convert the 'EXECUTION_START_DATE' column to datetime format
replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')

# Group by 'MAINTENANCE_TYPE_DESCRIPTION' to understand counts of replacements
grouped_replace = replace_rows.groupby('MAINTENANCE_TYPE_DESCRIPTION').size()
print("Counts of parts replaced by maintenance type:\n", grouped_replace)

# Calculate the new duration using the fixed future date
fixed_future_date = replace_rows['EXECUTION_START_DATE'].max()
replace_rows['duration_new'] = (fixed_future_date - replace_rows['EXECUTION_START_DATE']).dt.days

# Create an 'event_new' column indicating unplanned maintenance occurrence (1 for event)
replace_rows['event_new'] = 1  # Since replace_rows only has rows with unplanned events

# Initialize the Kaplan-Meier fitter
kmf = KaplanMeierFitter()

# Dictionary to store median survival times for each maintenance type
median_survival_times = {}

# List of key maintenance types for analysis
maintenance_types = [
    'Corrective Maintenance Order',
    'Administrative Order',
    'Preventive Maintenance Order'
]

# Plot Kaplan-Meier survival curves for each type of unplanned maintenance
plt.figure(figsize=(12, 8))

# Loop over each maintenance type and fit the Kaplan-Meier model
for maintenance_type in maintenance_types:
    if maintenance_type in replace_rows['MAINTENANCE_TYPE_DESCRIPTION'].unique():
        # Filter data for the current maintenance type
        type_df = replace_rows[replace_rows['MAINTENANCE_TYPE_DESCRIPTION'] == maintenance_type]

        # Fit the Kaplan-Meier model with duration and event data
        kmf.fit(durations=type_df['duration_new'], event_observed=type_df['event_new'], label=maintenance_type)

        # Store and print the median survival time for each type
        median_survival_times[maintenance_type] = kmf.median_survival_time_
        print(f"Median Survival Time for {maintenance_type}: {kmf.median_survival_time_} days")

        # Plot the survival function for this maintenance type
        kmf.plot_survival_function(ci_show=False)

# Label the plot for better visualization
plt.title("Kaplan-Meier Survival Curves for Different Maintenance Types (New Duration)")
plt.xlabel("Days Since Part Replacement")
plt.ylabel("Survival Probability")
plt.legend()
plt.grid(True)
plt.show()

# Output the calculated median survival times
print("\nMedian Survival Times (in days):")
for maintenance_type, median_time in median_survival_times.items():
    print(f"{maintenance_type}: {median_time} days")

<ipython-input-53-513457c13a07>:12: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['EXECUTION_START_DATE'] = pd.to_datetime(replace_rows['EXECUTION_START_DATE'], errors='coerce')
<ipython-input-53-513457c13a07>:24: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['duration_new'] = (fixed_future_date - replace_rows['EXECUTION_START_DATE']).dt.days
<ipython-input-53-513457c13a07>:27: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  replace_rows['event_new'] = 1  # Since replace_rows only has rows with unplanned events

Counts of parts replaced by maintenance type:
 MAINTENANCE_TYPE_DESCRIPTION
Administrative Order              266
Corrective Maintenance Order    23060
Preventive Maintenance Order       67
dtype: int64
Median Survival Time for Corrective Maintenance Order: 1231.0 days
Median Survival Time for Administrative Order: 364.0 days
Median Survival Time for Preventive Maintenance Order: 1288.0 days

Median Survival Times (in days):
Corrective Maintenance Order: 1231.0 days
Administrative Order: 364.0 days
Preventive Maintenance Order: 1288.0 days

# Fixed future date for censoring purposes
fixed_future_date = pd.to_datetime("2024-08-30")

# Calculate the duration to the fixed future date
data_swire_copy['EXECUTION_START_DATE'] = pd.to_datetime(data_swire_copy['EXECUTION_START_DATE'], errors='coerce')
data_swire_copy = data_swire_copy.dropna(subset=['EXECUTION_START_DATE'])  # Drop rows with NaT in EXECUTION_START_DATE
data_swire_copy['duration_new'] = (fixed_future_date - data_swire_copy['EXECUTION_START_DATE']).dt.days
data_swire_copy['event_new'] = 1  # Assuming all rows represent events

# Dictionary to store median survival times for each level
median_survival_times_by_level = {}

# List of hierarchical columns for analysis
hierarchical_levels = ['Plant', 'Process', 'Sub_Process', 'Product_Line', 'Machine', 'Sub_Machine']

# Loop through each level to calculate Kaplan-Meier curves and store median survival times
for level in hierarchical_levels:
    kmf = KaplanMeierFitter()
    median_survival_times_by_level[level] = {}

    for group in data_swire_copy[level].dropna().unique():  # Drop NaN and iterate over unique groups
        group_df = data_swire_copy[data_swire_copy[level] == group]

        # Fit Kaplan-Meier model for each group
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=str(group))

        # Store median survival time for each group in the current level
        median_survival_times_by_level[level][group] = kmf.median_survival_time_

# Display top 10 and lowest 10 median survival times for each level
for level in hierarchical_levels:
    print(f"\nTop 10 Median Survival Times for {level} (in days):")
    top_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1], reverse=True)[:10]
    for group, median_time in top_10:
        print(f"{level} - {group}: {median_time} days")

    print(f"\nLowest 10 Median Survival Times for {level} (in days):")
    low_10 = sorted(median_survival_times_by_level[level].items(), key=lambda x: x[1])[:10]
    for group, median_time in low_10:
        print(f"{level} - {group}: {median_time} days")

    # Plot the survival curves for the top 10 and lowest 10 groups
    plt.figure(figsize=(14, 8))
    kmf = KaplanMeierFitter()

    # Plot the top 10 groups
    for group, _ in top_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Top 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

    plt.figure(figsize=(14, 8))

    # Plot the lowest 10 groups
    for group, _ in low_10:
        group_df = data_swire_copy[data_swire_copy[level] == group]
        kmf.fit(durations=group_df['duration_new'], event_observed=group_df['event_new'], label=f"{level} - {group}")
        kmf.plot_survival_function(ci_show=False)

    plt.title(f"Kaplan-Meier Survival Curves for Lowest 10 {level} Groups by Median Survival Time")
    plt.xlabel("Days Since Last Maintenance")
    plt.ylabel("Survival Probability")
    plt.legend(title='Groups')
    plt.grid(True)
    plt.show()

Top 10 Median Survival Times for Plant (in days):
Plant - G221: 1505.0 days
Plant - G291: 1387.0 days
Plant - G261: 1244.0 days
Plant - G816: 1143.0 days
Plant - G811: 821.0 days
Plant - G812: 772.0 days
Plant - G999: 123.0 days

Lowest 10 Median Survival Times for Plant (in days):
Plant - G999: 123.0 days
Plant - G812: 772.0 days
Plant - G811: 821.0 days
Plant - G816: 1143.0 days
Plant - G261: 1244.0 days
Plant - G291: 1387.0 days
Plant - G221: 1505.0 days

Top 10 Median Survival Times for Process (in days):
Process - CLR: 1418.0 days
Process - FLT: 1376.0 days
Process - PRD: 1198.0 days
Process - SLC: 123.0 days

Lowest 10 Median Survival Times for Process (in days):
Process - SLC: 123.0 days
Process - PRD: 1198.0 days
Process - FLT: 1376.0 days
Process - CLR: 1418.0 days

Top 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P30: 2176.0 days
Sub_Process - L35: 1590.0 days
Sub_Process - A50: 1575.0 days
Sub_Process - P05: 1483.0 days
Sub_Process - A85: 1418.0 days
Sub_Process - F10: 1376.0 days
Sub_Process - P90: 1362.0 days
Sub_Process - A99: 1362.0 days
Sub_Process - P55: 1354.0 days
Sub_Process - L30: 1304.0 days

Lowest 10 Median Survival Times for Sub_Process (in days):
Sub_Process - P76: 143.0 days
Sub_Process - P95: 204.0 days
Sub_Process - B30: 230.0 days
Sub_Process - A40: 257.0 days
Sub_Process - A05: 267.0 days
Sub_Process - P50: 294.0 days
Sub_Process - A55: 339.0 days
Sub_Process - P91: 342.0 days
Sub_Process - P77: 373.0 days
Sub_Process - A28: 427.0 days

Top 10 Median Survival Times for Product_Line (in days):
Product_Line - L08: 1637.0 days
Product_Line - 006: 1585.0 days
Product_Line - I06: 1575.0 days
Product_Line - E06: 1412.0 days
Product_Line - 002: 1376.0 days
Product_Line - L04: 1329.0 days
Product_Line - L01: 1300.0 days
Product_Line - L02: 1293.0 days
Product_Line - S02: 1277.0 days
Product_Line - L09: 1256.0 days

Lowest 10 Median Survival Times for Product_Line (in days):
Product_Line - L10: 21.0 days
Product_Line - S04: 42.0 days
Product_Line - W15: 61.0 days
Product_Line - H00: 120.0 days
Product_Line - E01: 121.0 days
Product_Line - I08: 123.0 days
Product_Line - 020: 123.0 days
Product_Line - W01: 130.0 days
Product_Line - E03: 141.0 days
Product_Line - W09: 165.0 days

Top 10 Median Survival Times for Machine (in days):
Machine - S250: 2176.0 days
Machine - S280: 1727.0 days
Machine - S090: 1695.0 days
Machine - L160: 1681.0 days
Machine - 0007: 1638.0 days
Machine - L010: 1616.0 days
Machine - L170: 1592.0 days
Machine - L070: 1576.0 days
Machine - S080: 1552.0 days
Machine - L100: 1525.0 days

Lowest 10 Median Survival Times for Machine (in days):
Machine - S005: 4.0 days
Machine - C030: 5.0 days
Machine - C040: 43.0 days
Machine - S002: 45.0 days
Machine - L230: 59.0 days
Machine - S004: 75.0 days
Machine - S000: 89.0 days
Machine - S030: 97.0 days
Machine - L220: 108.0 days
Machine - S001: 117.0 days

Top 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - WEST: 1630.0 days
Sub_Machine - L010: 1234.0 days
Sub_Machine - 0020: 1196.0 days
Sub_Machine - 0040: 1169.0 days
Sub_Machine - 0035: 1123.0 days
Sub_Machine - 0030: 1001.0 days
Sub_Machine - 0050: 924.0 days
Sub_Machine - 0010: 857.0 days
Sub_Machine - 0060: 830.0 days
Sub_Machine - L040: 745.0 days

Lowest 10 Median Survival Times for Sub_Machine (in days):
Sub_Machine - 050: 34.0 days
Sub_Machine - INS: 129.0 days
Sub_Machine - ACMI: 169.0 days
Sub_Machine - 0025: 170.0 days
Sub_Machine - 0200: 174.0 days
Sub_Machine - MEAD: 178.0 days
Sub_Machine - OUT: 304.0 days
Sub_Machine - 010: 360.0 days
Sub_Machine - 0022: 371.0 days
Sub_Machine - 040: 402.0 days

	ACTUAL_WORK_IN_MINUTES
count	1427264.00
mean	88.63
std	803.79
min	0.00
25%	12.00
50%	48.00
75%	90.00
max	330184.80

	Average_Interval_Days	Average_Interval_Weeks
EQUIPMENT_ID
300001113.0	1.407007	0.201001
300001078.0	1.566667	0.223810
300254600.0	1.580838	0.225834
300001612.0	1.625714	0.232245
300220209.0	1.779736	0.254248
...	...	...
300001090.0	389.000000	55.571429
300001143.0	389.000000	55.571429
300001325.0	464.000000	66.285714
300001054.0	545.500000	77.928571
400022400.0	640.000000	91.428571

	ORDER_ID	PLANT_ID	PRODUCTION_LOCATION	EXECUTION_START_DATE	EXECUTION_FINISH_DATE	ACTUAL_START_TIME	ACTUAL_FINISH_TIME	ACTUAL_WORK_IN_MINUTES	MAINTENANCE_PLAN	MAINTENANCE_ITEM	...	FUNCTIONAL_AREA_NODE_2_MODIFIED	FUNCTIONAL_AREA_NODE_3_MODIFIED	FUNCTIONAL_AREA_NODE_4_MODIFIED	FUNCTIONAL_AREA_NODE_5_MODIFIED	EQUIPMENT_ID	EQUIPMENT_DESC	EQUIP_CAT_DESC	EQUIP_START_UP_DATE	EQUIP_VALID_FROM	EQUIP_VALID_TO
0	705642457.0	G812	ROMA	5/4/2024	5/12/2024	00:00.0	04:08.0	390.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	4/22/2020	2/10/2020	12/31/9999
1	704191697.0	G812	ROMA	9/13/2022	9/13/2022	00:00.0	17:24.0	420.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	4/22/2020	2/10/2020	12/31/9999
2	704466547.0	G812	ROMA	12/21/2022	12/21/2022	00:00.0	00:00.0	30.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	4/22/2020	2/10/2020	12/31/9999
3	703834477.0	G812	ROMA	7/4/2022	7/4/2022	00:00.0	00:00.0	60.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	4/22/2020	2/10/2020	12/31/9999
4	704661125.0	G291	MONZA	3/15/2023	3/15/2023	00:00.0	00:00.0	120.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2/15/2017	12/11/2023	12/31/9999
5	704948720.0	G291	MONZA	9/8/2023	9/8/2023	00:00.0	00:00.0	18.0	G291VM1437	40534.0	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2/15/2017	12/11/2023	12/31/9999
6	701673970.0	G291	MONZA	9/6/2019	9/6/2019	00:00.0	00:00.0	480.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2/15/2017	12/11/2023	12/31/9999
7	705148892.0	G291	MONZA	10/9/2023	10/9/2023	00:00.0	00:00.0	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2/15/2017	12/11/2023	12/31/9999
8	704769592.0	G291	MONZA	5/1/2023	5/1/2023	00:00.0	00:00.0	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2/15/2017	12/11/2023	12/31/9999
9	704448350.0	G291	MONZA	12/13/2022	12/13/2022	00:00.0	00:00.0	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2/15/2017	12/11/2023	12/31/9999

	0
ORDER_ID	int64
PLANT_ID	object
PRODUCTION_LOCATION	object
EXECUTION_START_DATE	object
EXECUTION_FINISH_DATE	object
ACTUAL_START_TIME	object
ACTUAL_FINISH_TIME	object
ACTUAL_WORK_IN_MINUTES	float64
MAINTENANCE_PLAN	object
MAINTENANCE_ITEM	float64
MAINTENANCE_ACTIVITY_TYPE	object
ORDER_DESCRIPTION	object
MAINTENANCE_TYPE_DESCRIPTION	object
FUNCTIONAL_LOC	object
FUNCTIONAL_AREA_NODE_1_MODIFIED	object
FUNCTIONAL_AREA_NODE_2_MODIFIED	object
FUNCTIONAL_AREA_NODE_3_MODIFIED	object
FUNCTIONAL_AREA_NODE_4_MODIFIED	object
FUNCTIONAL_AREA_NODE_5_MODIFIED	object
EQUIPMENT_ID	float64
EQUIPMENT_DESC	object
EQUIP_CAT_DESC	object
EQUIP_START_UP_DATE	object
EQUIP_VALID_FROM	object
EQUIP_VALID_TO	object

	ORDER_ID	PLANT_ID	PRODUCTION_LOCATION	EXECUTION_START_DATE	EXECUTION_FINISH_DATE	ACTUAL_START_TIME	ACTUAL_FINISH_TIME	ACTUAL_WORK_IN_MINUTES	MAINTENANCE_PLAN	MAINTENANCE_ITEM	...	FUNCTIONAL_AREA_NODE_2_MODIFIED	FUNCTIONAL_AREA_NODE_3_MODIFIED	FUNCTIONAL_AREA_NODE_4_MODIFIED	FUNCTIONAL_AREA_NODE_5_MODIFIED	EQUIPMENT_ID	EQUIPMENT_DESC	EQUIP_CAT_DESC	EQUIP_START_UP_DATE	EQUIP_VALID_FROM	EQUIP_VALID_TO
0	705642457	G812	ROMA	2024-05-04	2024-05-12	06:00:00.000	23:04:08.000	390.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
1	704191697	G812	ROMA	2022-09-13	2022-09-13	06:00:00.000	17:17:24.000	420.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
2	704466547	G812	ROMA	2022-12-21	2022-12-21	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
3	703834477	G812	ROMA	2022-07-04	2022-07-04	06:00:00.000	06:00:00.000	60.0	NaN	NaN	...	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	FULL CAN CONVEYOR	300126812.0	FULL CAN CONVEYOR (FC41B)	Machines	2020-04-22	2020-02-10	9999-12-31
4	704661125	G291	MONZA	2023-03-15	2023-03-15	07:00:00.000	07:00:00.000	120.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
5	704948720	G291	MONZA	2023-09-08	2023-09-08	07:00:00.000	07:00:00.000	18.0	G291VM1437	40534.0	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
6	701673970	G291	MONZA	2019-09-06	2019-09-06	07:00:00.000	07:00:00.000	480.0	NaN	NaN	...	AIR SYSTEMS	NaN	NaN	NaN	300001088.0	TANK_STL_STOR_AIR	Machines	2017-02-15	2023-12-11	9999-12-31
7	705148892	G291	MONZA	2023-10-09	2023-10-09	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31
8	704769592	G291	MONZA	2023-05-01	2023-05-01	07:00:00.000	07:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31
9	704448350	G291	MONZA	2022-12-13	2022-12-13	08:00:00.000	08:00:00.000	30.0	NaN	NaN	...	AMMONIA & REFRIGERATION SYSTEMS	NaN	NaN	NaN	300001033.0	PUMP_RECIP_HIGH_PRESSURE_NF	Machines	2017-02-15	2023-12-11	9999-12-31

	FUNCTIONAL_AREA_NODE_1_MODIFIED	FUNCTIONAL_AREA_NODE_2_MODIFIED	FUNCTIONAL_AREA_NODE_3_MODIFIED	FUNCTIONAL_AREA_NODE_4_MODIFIED	FUNCTIONAL_AREA_NODE_5_MODIFIED	Maintenance_Frequency	Average_Downtime
0	MONZA PRODUCTION	ROTARY_CAN_LINE	LINE #4-FILLER_ROTARY_CAN	PACKER	PACKER 1, MODEL DUODOZEN 1250SX	210	208.837143
1	PRODUCTION	G812 PRD FILLER_ROTARY_CAN	G812 PRD FILLER_ROTARY_CAN LINE 3	CONVEYOR	EMPTY CAN CONVEYOR	66	104.190909
2	MONZA PRODUCTION	BTL_PET_LINE	LINE #3 - FILLER_ROT_BTL_PET	WARMER_COOLER	EVANS COOLING TUNNEL L3, INSIDE BUILDING	43	117.530233
3	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 3 SMALL PET	CONVEYOR	LOOSE FB TO PACKER CONVEYORS	29	82.758621
4	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 2 LARGET PET	CONVEYOR	FULL CASE CONVEYORS	21	161.428571
5	PRODUCTION	LINE 1 CAN	LINE 1 CAN	CONVEYOR	EMPTY CAN	20	126.750000
6	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 3 SMALL PET	CONVEYOR	INFEED TO HICONE TO PACKER	15	130.400000
7	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 2 LARGET PET	CONVEYOR	EMPTY CASE CONVEYORS	13	108.461538
8	PRODUCTION	LINE 1 CAN	LINE 1 CAN	CONVEYOR	EMPTY CAN VACUUM BLOWERS	9	120.000000
9	PRODUCTION	LINE 2,3 PET BOTTLE LINES	LINE 3 SMALL PET	CONVEYOR	FB CONVEYORS TO DOUGLAS/HI-CONE SPLIT	8	468.750000

Swire Coca-Cola Capstone Modeling

Author : Adarsh Fnu

Table of contents:¶

1. Introduction ¶

2. Load Libraries and packages ¶

3. Import dataset and inspect ¶

4. Missing Value analysis ¶

4.1 Imputation of Missing Value's ¶

5.Univariate analysis ¶

5.1. Distribution of actual work in minutes ¶

5.2. Breakdown counts by production location ¶

5.3. Breakdown trends over years ¶

5.4. Number of maintenance activites per month in 2023 ¶

5.5. Frequency of maintenance activity type ¶

6.Bivariate analysis ¶

6.1 Average downtime by maintenance activity type ¶

6.2 Average downtime by plant ¶

6.3 Count of Maintenance type by maintenance activity type ¶

6.4 Production line Analysis using Functional Area ¶

6.4.1 Average downtime by functional area node 4 ¶

6.4.2 Average downtime by functional area node 5 ¶

6.5 Frequency of Maintenance Type Across Equipment Categories ¶

6.6 Scatter Plot of Equipment Age vs Actual Work in Minutes ¶

7.Multivariate analysis ¶

7.1 Average Downtime by Maintenance Activity Type for Different Plants ¶

7.2 Maintenance Type by Equipment Age and Downtime ¶

8. Outlier Analysis ¶

9. Feature Engineering ¶

9.1 Breakdown Analysis by Equipment Type ¶

9.2 Breakdown Timeline Analysis ¶

9.3 Machine Location and Granular Analysis ¶

9.4 Nature of Repairs and Correction Methods ¶

9.5. Equipment-Specific Time Between Failures ¶

9.6 Maintenance Frequency and Downtime ¶

9.7. Time Until Next Downtime Post-Maintenance ¶

9.8 Seasonal Impact and Cost Analysis ¶

9.9 Key Features for Modeling ¶

10. Model Selection ¶

10.1. Linear Regression ¶

10.2. Random Forest Model ¶

10.3 XGBoost Model ¶

10.4 Lightgbm Model ¶

11. Modeling ¶

11.1 Functional Location Segmentation for Process Analysis ¶

11.2 Kaplan-Meier Model ¶

11.3 Leveraging Kaplan-Meier Model for Enhanced Insights ¶

12. Individual Contributions ¶